// 性能优化工具类

/**
 * 防止频繁触发的节流函数
 * @param {Function} func - 要执行的函数
 * @param {number} delay - 延迟时间(ms)
 * @returns {Function} 节流后的函数
 */
export function throttle(func, delay) {
  let timer = null;
  let lastTime = 0;
  
  return function(...args) {
    const now = Date.now();
    
    // 如果距离上次执行时间超过延迟时间，则立即执行
    if (now - lastTime > delay) {
      func.apply(this, args);
      lastTime = now;
    } else {
      // 否则，清除之前的定时器，重新设置定时器
      clearTimeout(timer);
      timer = setTimeout(() => {
        func.apply(this, args);
        lastTime = Date.now();
      }, delay - (now - lastTime));
    }
  };
}

/**
 * 防止频繁触发的防抖函数
 * @param {Function} func - 要执行的函数
 * @param {number} delay - 延迟时间(ms)
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, delay) {
  let timer = null;
  
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

/**
 * 图片懒加载
 * @param {string} src - 图片地址
 * @param {string} placeholder - 占位图地址
 * @returns {string} 处理后的图片地址
 */
export function lazyLoadImage(src, placeholder = '/static/placeholder.png') {
  // 在实际项目中，这里可以实现图片懒加载逻辑
  // 目前我们只是简单返回原图片地址
  return src || placeholder;
}

/**
 * 数据缓存工具
 */
class DataCache {
  constructor() {
    this.cache = new Map();
    this.maxAge = 5 * 60 * 1000; // 默认缓存5分钟
  }
  
  /**
   * 设置缓存
   * @param {string} key - 缓存键
   * @param {any} value - 缓存值
   * @param {number} maxAge - 过期时间(ms)
   */
  set(key, value, maxAge = this.maxAge) {
    const expireTime = Date.now() + maxAge;
    this.cache.set(key, {
      value,
      expireTime
    });
  }
  
  /**
   * 获取缓存
   * @param {string} key - 缓存键
   * @returns {any} 缓存值
   */
  get(key) {
    const item = this.cache.get(key);
    
    if (!item) {
      return null;
    }
    
    // 检查是否过期
    if (Date.now() > item.expireTime) {
      this.cache.delete(key);
      return null;
    }
    
    return item.value;
  }
  
  /**
   * 删除缓存
   * @param {string} key - 缓存键
   */
  delete(key) {
    this.cache.delete(key);
  }
  
  /**
   * 清空缓存
   */
  clear() {
    this.cache.clear();
  }
}

// 创建全局缓存实例
export const dataCache = new DataCache();

/**
 * 页面性能监控
 */
export class PerformanceMonitor {
  constructor() {
    this.startTime = Date.now();
    this.markers = new Map();
  }
  
  /**
   * 标记时间点
   * @param {string} name - 标记名称
   */
  mark(name) {
    this.markers.set(name, Date.now() - this.startTime);
  }
  
  /**
   * 测量两个标记之间的时间差
   * @param {string} startMark - 起始标记
   * @param {string} endMark - 结束标记
   * @returns {number} 时间差(ms)
   */
  measure(startMark, endMark) {
    const start = this.markers.get(startMark);
    const end = this.markers.get(endMark);
    
    if (start === undefined || end === undefined) {
      console.warn('标记不存在');
      return 0;
    }
    
    return end - start;
  }
  
  /**
   * 获取页面加载时间
   * @returns {number} 页面加载时间(ms)
   */
  getPageLoadTime() {
    return Date.now() - this.startTime;
  }
}

export default {
  throttle,
  debounce,
  lazyLoadImage,
  dataCache,
  PerformanceMonitor
};